from flask_sqlalchemy import SQLAlchemy # 保留，虽然可能不是必需的
from werkzeug.security import generate_password_hash, check_password_hash
# import json # 如果不需要，可以删除

# 导入共享的 db 实例
from . import db
# from sqlalchemy.dialects import postgresql # 如果明确使用 JSONB，取消注释

class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    password_hash = db.Column(db.String(128), nullable=False)
    role = db.Column(db.String(20), nullable=False)

    def set_password(self, password):
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        return check_password_hash(self.password_hash, password)

    def __repr__(self):
        return f'<User {self.username}>'

    # --- 添加 to_dict 方法 ---
    def to_dict(self):
        """将 User 对象转换为字典格式（不包含敏感信息如密码哈希）"""
        return {
            'id': self.id,
            'username': self.username,
            'role': self.role
        }
    # --- 结束 to_dict 方法 ---

class OutcomeType(db.Model):
    __tablename__ = 'outcome_types'
    id = db.Column(db.String(50), primary_key=True)
    name = db.Column(db.String(100), unique=True, nullable=False)
    # 使用 SQLAlchemy 的 JSON 类型
    # config_data = db.Column(postgresql.JSONB, nullable=False) # 如果用 PG JSONB
    config_data = db.Column(db.JSON, nullable=False)

    def __repr__(self):
        return f'<OutcomeType {self.name}>'

    # --- 添加 to_dict 方法 ---
    def to_dict(self):
        """将 OutcomeType 对象转换为字典格式"""
        return {
            'id': self.id,
            'name': self.name,
            # config_data 通常已经是 Python 字典或列表，可以直接返回
            'config_data': self.config_data
        }
    # --- 结束 to_dict 方法 ---


class Outcome(db.Model):
    __tablename__ = 'outcomes'
    id = db.Column(db.Integer, primary_key=True)
    outcome_type_id = db.Column(db.String(50), db.ForeignKey('outcome_types.id'), nullable=False)
    submitter_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
    submit_date = db.Column(db.Date, nullable=False, default=db.func.current_date())
    status = db.Column(db.String(20), nullable=False)
    review_date = db.Column(db.Date, nullable=True)
    rejection_reason = db.Column(db.Text, nullable=True)
    # 使用 SQLAlchemy 的 JSON 类型
    # outcome_data = db.Column(postgresql.JSONB, nullable=False) # 如果用 PG JSONB
    outcome_data = db.Column(db.JSON, nullable=False)

    # 定义关系
    submitter = db.relationship('User', backref=db.backref('outcomes', lazy=True))
    outcome_type = db.relationship('OutcomeType', backref=db.backref('outcomes', lazy=True))

    __table_args__ = (
        db.Index('idx_outcomes_status', 'status'),
        db.Index('idx_outcomes_submitter', 'submitter_id'),
        db.Index('idx_outcomes_type', 'outcome_type_id'),
        # 如果需要 CHECK 约束且未通过迁移管理，在此添加
    )

    def __repr__(self):
         type_name = self.outcome_type.name if self.outcome_type else f'type_id={self.outcome_type_id}'
         return f'<Outcome {self.id} ({type_name})>'

    # --- 添加 to_dict 方法 ---
    def to_dict(self):
        """将 Outcome 对象转换为字典格式"""
        return {
            'id': self.id,
            'outcome_type_id': self.outcome_type_id,
            'submitter_id': self.submitter_id,
            # 将日期对象转换为 ISO 格式的字符串，这是 JSON 序列化的常见做法
            # 同时处理可能为 None 的情况
            'submit_date': self.submit_date.isoformat() if self.submit_date else None,
            'status': self.status,
            'review_date': self.review_date.isoformat() if self.review_date else None,
            'rejection_reason': self.rejection_reason,
            # outcome_data 通常已经是 Python 字典或列表，可以直接返回
            'outcome_data': self.outcome_data,
            # 可选：如果需要，可以包含关联对象的基本信息
            # 'submitter_info': self.submitter.to_dict() if self.submitter else None,
            # 'outcome_type_info': self.outcome_type.to_dict() if self.outcome_type else None
        }
    # --- 结束 to_dict 方法 ---

